home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 001-025 / disk_004 / kermit / receive.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  5KB  |  259 lines
  1. /*    @(#)receive.c    1.1    1/26/85    */
  2.  
  3. /*
  4.  *    receive - routines for receiving data
  5.  *
  6.  *    r e c s w
  7.  */
  8.  
  9. #include "kermit.h"
  10. #include "errors.h"
  11.  
  12. static char rinit ();
  13. static char rfile ();
  14. static char rdata ();
  15.  
  16.  
  17. VOID Receive ()
  18. {
  19.     DBUG_ENTER ("receive");
  20.     DBUG_2 ("rec", "begin receive attempt");
  21.     if (recsw () == FALSE) {
  22.     (VOID) printf ("Receive failed.\n");
  23.     } else {
  24.     (VOID) printf ("OK\n");
  25.     }
  26.     DBUG_VOID_RETURN;
  27. }
  28.  
  29.  
  30. recsw ()
  31. {
  32.     DBUG_ENTER ("recsw");
  33.     DBUG_2 ("init", "initializing receive variables");
  34.     state = 'R';        /* receive is the start state */
  35.     n = 0;            /* initialize message number */
  36.     numtry = 0;            /* say no tries yet */
  37.     while (TRUE) {        /* do this as long as necessary */
  38.     DBUG_3 ("states", "state %c found", state);
  39.     switch (state) {
  40.         case 'D': 
  41.         state = rdata ();
  42.         break;        /* data receive state */
  43.         case 'F': 
  44.         state = rfile ();
  45.         break;        /* fil receive state */
  46.         case 'R': 
  47.         state = rinit ();
  48.         break;        /* send initiate state */
  49.         case 'C': 
  50.         DBUG_RETURN (TRUE);    /* complte state */
  51.         case 'A': 
  52.         DBUG_RETURN (FALSE);    /* unknown state, abort */
  53.     }
  54.     }
  55. }
  56.  
  57.  
  58. /*
  59.  *     r i n i t
  60.  */
  61.  
  62. static char rinit ()
  63. {
  64.     auto int len;
  65.     auto int num;
  66.     register char newstate;
  67.  
  68.     DBUG_ENTER ("rinit");
  69.     if (numtry++ > MAXTRY) {
  70.     newstate = 'A';
  71.     } else {
  72.     DBUG_2 ("state", "begin receive init");
  73.     switch (rpack (&len, &num, packet)) {
  74.         case 'S':                 /* send-init */
  75.         DBUG_2 ("init", "got S packet");
  76.         rpar (packet);            /* get the init data */
  77.         spar (packet);        /* fill up packet with init info */
  78.         spack ('Y', n, 6, packet);    /* ACK with my parameters */
  79.         oldtry = numtry;
  80.         numtry = 0;            /* and start a new counter */
  81.         n = (n + 1) % 64;        /* bump packet number */
  82.         newstate = 'F';
  83.         break;
  84.         case FALSE: 
  85.         DBUG_2 ("init", "no S packet");
  86.         newstate = state;
  87.         break;
  88.         default: 
  89.         newstate = 'A';
  90.         break;
  91.     }
  92.     }
  93.     DBUG_3 ("states", "new state %c", newstate);
  94.     DBUG_RETURN (newstate);
  95. }
  96.  
  97.  
  98. /*
  99.  *    r f i l e
  100.  */
  101.  
  102. static char rfile ()
  103. {
  104.     auto int num;
  105.     auto int len;
  106.     char *bp;
  107.     register char newstate;
  108.  
  109.     DBUG_ENTER ("rfile");
  110.     if (numtry++ > MAXTRY) {
  111.     DBUG_3 ("tries", "%d tries", numtry - 1);
  112.     newstate = 'A';
  113.     } else {
  114.     switch (rpack (&len, &num, packet)) {
  115.         case 'S':
  116.         DBUG_2 ("S", "got S packet");
  117.         if (oldtry++ > MAXTRY) {
  118.             newstate = 'A';
  119.         } else if (num == n - 1) {
  120.             spar (packet);
  121.             spack ('Y', num, 6, packet);
  122.             numtry = 0;
  123.             newstate = state;
  124.         } else {
  125.             newstate = 'A';
  126.         }
  127.         break;
  128.         case 'Z':                 /* end-of-file */
  129.         if (oldtry++ > MAXTRY) {
  130.             newstate = 'A';
  131.         } else if (num == n - 1) {    /* acknowledge good packet */
  132.             spack ('Y', num, 0, packet);
  133.             numtry = 0;
  134.             newstate = state;
  135.         } else {
  136.             newstate = 'A';
  137.         }
  138.         break;
  139.         case 'F':                 /* file-header */
  140.         if (num != n) {
  141.             newstate = 'A';
  142.             break;
  143.         }
  144.         DBUG_3 ("pack", "converting %s", packet);
  145.         if (mflg) {
  146.             for (bp = &packet[0]; *bp != NULL; bp++) {
  147.             *bp = tolower(*bp);
  148.             }
  149.         }
  150.         DBUG_3 ("files", "open file %s", packet);
  151.         if (!getfil (packet)) {
  152.             Error (RCVFILE, packet);
  153.             newstate = 'A';
  154.         } else {
  155.             if (host) {
  156.             (VOID) printf ("Receiving %s\n", packet);
  157.             }
  158.             spack ('Y', n, 0, packet);        /* acknowledge */
  159.             oldtry = numtry;
  160.             numtry = 0;
  161.             n = (n + 1) % 64;
  162.             newstate = 'D';
  163.         }
  164.         break;
  165.         case 'B':
  166.         if (num != n) {
  167.             newstate = 'A';
  168.         } else {
  169.             spack ('Y', n, 0, packet);
  170.             newstate = 'C';
  171.         }
  172.         break;
  173.         case FALSE: 
  174.         newstate = state;
  175.         break;
  176.         default: 
  177.         newstate = 'A';
  178.         break;
  179.     }
  180.     }
  181.     DBUG_3 ("states", "new state %c", newstate);
  182.     DBUG_RETURN (newstate);
  183. }
  184.  
  185.  
  186. /*
  187.  *    r d a t a
  188.  */
  189.  
  190. static char rdata ()
  191. {
  192.     auto int num;
  193.     auto int len;
  194.     register char newstate;
  195.  
  196.     DBUG_ENTER ("rdata");
  197.     DBUG_2 ("rcv", "receive data");
  198.     if (numtry++ > MAXTRY) {
  199.     newstate = 'A';
  200.     } else {
  201.     switch (rpack (&len, &num, packet)) {        /* get packet */
  202.         case 'D':                     /* data */
  203.         DBUG_2 ("rcv", "got D packet");
  204.         DBUG_3 ("rcv", "length %d", len);
  205.         if (num != n) {                /* right packet? */
  206.             if (oldtry++ > MAXTRY) {
  207.             newstate = 'A';
  208.             } else if (num == n - 1) {
  209.             spar (packet);
  210.             spack ('Y', num, 6, packet);
  211.             numtry = 0;
  212.             newstate = state;
  213.             } else {
  214.             newstate = 'A';
  215.             }
  216.         } else {
  217.             bufemp (packet, fd, len);
  218.             spack ('Y', n, 0, packet);
  219.             oldtry = numtry;
  220.             numtry = 0;
  221.             n = (n + 1) % 64;
  222.             newstate = 'D';
  223.         }
  224.         break;
  225.         case 'F':                     /* file-send */
  226.         DBUG_2 ("rcv", "got F packet");        
  227.         if (oldtry++ > MAXTRY) {
  228.             newstate = 'A';
  229.         } else if (num == n - 1) {        /* ack good packet */
  230.             spack ('Y', num, 0, packet);
  231.             numtry = 0;
  232.             newstate = state;
  233.         } else {
  234.             newstate = 'A';
  235.         }
  236.         break;
  237.         case 'Z':                     /* end-of-file */
  238.         DBUG_2 ("rcv", "got Z packet");
  239.         if (num != n) {
  240.             newstate = 'A';
  241.         } else {
  242.             spack ('Y', n, 0, packet);        /* say OK */
  243.             (VOID) close (fd);            /* close up file */
  244.             n = (n + 1) % 64;
  245.             newstate = 'F';
  246.         }
  247.         break;
  248.         case FALSE: 
  249.         newstate = state;
  250.         break;
  251.         default: 
  252.         newstate = 'A';
  253.         break;
  254.     }
  255.     }
  256.     DBUG_3 ("states", "new state %c", newstate);
  257.     DBUG_RETURN (newstate);
  258. }
  259.